/**
 * 百度智能云人脸识别API服务
 * 提供人脸注册、人脸搜索、人脸检测等功能
 * 
 * @author 项目开发团队
 * @version 1.0.0
 */

import axios from 'axios';

// API配置
const API_CONFIG = {
  // 百度智能云API Key和Secret Key
  API_KEY: '6SmRe9qjkE1vSLVEhagQbz6A',
  SECRET_KEY: '14gP7z1ZewR8qWb9Ps3LffpJarJ1Eqam',
  
  // API基础URL - 使用代理路径
  BASE_URL: '/api/baidu/rest/2.0/face/v3',
  
  // 用户组ID
  GROUP_ID: 'medical_app_users',
  
  // 请求超时时间
  TIMEOUT: 10000
};

// 创建axios实例
const faceAPI = axios.create({
  baseURL: API_CONFIG.BASE_URL,
  timeout: API_CONFIG.TIMEOUT,
  headers: {
    'Content-Type': 'application/json; charset=UTF-8'
  }
});

// 获取访问令牌
let accessToken = null;
let tokenExpireTime = 0;

/**
 * 获取百度智能云访问令牌
 * @returns {Promise<string>} 访问令牌
 */
const getAccessToken = async () => {
  // 如果token未过期，直接返回
  if (accessToken && Date.now() < tokenExpireTime) {
    return accessToken;
  }

  try {
    const response = await axios.post('/api/baidu/oauth/2.0/token', null, {
      params: {
        grant_type: 'client_credentials',
        client_id: API_CONFIG.API_KEY,
        client_secret: API_CONFIG.SECRET_KEY
      }
    });

    if (response.data && response.data.access_token) {
      accessToken = response.data.access_token;
      // 设置token过期时间（提前5分钟过期）
      tokenExpireTime = Date.now() + (response.data.expires_in - 300) * 1000;
      return accessToken;
    } else {
      throw new Error('获取访问令牌失败');
    }
  } catch (error) {
    console.error('获取访问令牌失败:', error);
    
    // 根据错误类型提供更友好的错误信息
    if (error.code === 'ERR_NETWORK' || error.message.includes('Network Error')) {
      throw new Error('网络连接失败，请检查网络连接或稍后重试');
    } else if (error.response?.status === 401) {
      throw new Error('API密钥无效，请联系管理员');
    } else if (error.response?.status === 403) {
      throw new Error('API访问被拒绝，请检查权限设置');
    } else {
      throw new Error('获取访问令牌失败: ' + (error.message || '未知错误'));
    }
  }
};

/**
 * 将图片文件转换为Base64编码
 * @param {File} file 图片文件
 * @returns {Promise<string>} Base64编码的图片数据
 */
export const convertImageToBase64 = (file) => {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.onload = () => {
      const base64 = reader.result.split(',')[1]; // 移除data:image/jpeg;base64,前缀
      resolve(base64);
    };
    reader.onerror = reject;
    reader.readAsDataURL(file);
  });
};

/**
 * 人脸检测
 * @param {string} image Base64编码的图片数据
 * @param {string} imageType 图片类型 'BASE64' | 'FACE_TOKEN'
 * @returns {Promise<Object>} 检测结果
 */
export const detectFace = async (image, imageType = 'BASE64') => {
  try {
    const token = await getAccessToken();
    
    const response = await faceAPI.post('/detect', {
      image,
      image_type: imageType,
      face_field: 'age,beauty,expression,face_shape,gender,glasses,landmark,landmark150,quality,eye_status,emotion,face_type,mask,spoofing'
    }, {
      params: { access_token: token }
    });

    if (response.data.error_code) {
      throw new Error(response.data.error_msg || '人脸检测失败');
    }

    return {
      success: true,
      data: response.data.result
    };
  } catch (error) {
    console.error('人脸检测失败:', error);
    return {
      success: false,
      error: error.message
    };
  }
};

/**
 * 人脸注册
 * @param {string} image Base64编码的图片数据
 * @param {string} userId 用户ID
 * @param {string} userInfo 用户信息
 * @param {Object} options 可选参数
 * @returns {Promise<Object>} 注册结果
 */
export const registerFace = async (image, userId, userInfo = '', options = {}) => {
  try {
    const token = await getAccessToken();
    
    const requestData = {
      image,
      image_type: 'BASE64',
      group_id: API_CONFIG.GROUP_ID,
      user_id: userId,
      user_info: userInfo,
      quality_control: options.qualityControl || 'NORMAL',
      liveness_control: options.livenessControl || 'NORMAL',
      spoofing_control: options.spoofingControl || 'NORMAL',
      action_type: options.actionType || 'APPEND',
      face_sort_type: options.faceSortType || 0
    };

    const response = await faceAPI.post('/faceset/user/add', requestData, {
      params: { access_token: token }
    });

    if (response.data.error_code) {
      throw new Error(response.data.error_msg || '人脸注册失败');
    }

    return {
      success: true,
      data: response.data.result
    };
  } catch (error) {
    console.error('人脸注册失败:', error);
    return {
      success: false,
      error: error.message
    };
  }
};

/**
 * 人脸搜索（1:N识别）
 * @param {string} image Base64编码的图片数据或FACE_TOKEN
 * @param {Object} options 可选参数
 * @param {string} options.imageType 图片类型 'BASE64' | 'FACE_TOKEN'
 * @param {string} options.groupIdList 用户组ID列表，用逗号分隔
 * @param {string} options.qualityControl 图片质量控制 'NONE' | 'LOW' | 'NORMAL' | 'HIGH'
 * @param {string} options.livenessControl 活体检测控制 'NONE' | 'LOW' | 'NORMAL' | 'HIGH'
 * @param {string} options.spoofingControl 合成图控制 'NONE' | 'LOW' | 'NORMAL' | 'HIGH'
 * @param {string} options.userId 特定用户ID（人脸认证功能）
 * @param {number} options.maxUserNum 返回用户数量，默认1，最多50
 * @param {number} options.faceSortType 人脸检测排序类型 0:按面积 1:按距离中心
 * @param {number} options.matchThreshold 匹配阈值，推荐80
 * @returns {Promise<Object>} 搜索结果
 */
export const searchFace = async (image, options = {}) => {
  try {
    const token = await getAccessToken();
    
    const requestData = {
      image,
      image_type: options.imageType || 'BASE64',
      group_id_list: options.groupIdList || API_CONFIG.GROUP_ID,
      quality_control: options.qualityControl || 'NORMAL',
      liveness_control: options.livenessControl || 'NORMAL',
      spoofing_control: options.spoofingControl || 'NORMAL',
      max_user_num: options.maxUserNum || 1,
      face_sort_type: options.faceSortType || 0,
      match_threshold: options.matchThreshold || 80
    };

    // 只有当user_id有值时才添加这个参数
    if (options.userId && options.userId.trim() !== '') {
      requestData.user_id = options.userId;
    }

    const response = await faceAPI.post('/search', requestData, {
      params: { access_token: token }
    });

    if (response.data.error_code) {
      throw new Error(response.data.error_msg || '人脸搜索失败');
    }

    return {
      success: true,
      data: response.data.result,
      faceToken: response.data.result?.face_token
    };
  } catch (error) {
    console.error('人脸搜索失败:', error);
    
    // 根据错误类型提供更友好的错误信息
    if (error.message.includes('quality')) {
      return {
        success: false,
        error: '图片质量不符合要求，请确保光线充足、人脸清晰',
        errorType: 'quality'
      };
    } else if (error.message.includes('liveness')) {
      return {
        success: false,
        error: '活体检测失败，请确保是真人操作',
        errorType: 'liveness'
      };
    } else if (error.message.includes('spoofing')) {
      return {
        success: false,
        error: '检测到合成图片，请使用真实照片',
        errorType: 'spoofing'
      };
    } else if (error.message.includes('qps request limit')) {
      return {
        success: false,
        error: 'API调用频率过高，请稍后再试',
        errorType: 'rate_limit'
      };
    } else {
      return {
        success: false,
        error: error.message || '人脸搜索失败',
        errorType: 'unknown'
      };
    }
  }
};

/**
 * 人脸验证（1:1比对）
 * @param {string} image1 Base64编码的第一张图片
 * @param {string} image2 Base64编码的第二张图片
 * @param {Object} options 可选参数
 * @returns {Promise<Object>} 验证结果
 */
export const verifyFace = async (image1, image2, options = {}) => {
  try {
    const token = await getAccessToken();
    
    const requestData = {
      image_1: image1,
      image_type_1: 'BASE64',
      image_2: image2,
      image_type_2: 'BASE64',
      quality_control: options.qualityControl || 'NORMAL',
      liveness_control: options.livenessControl || 'NORMAL',
      face_type: options.faceType || 'LIVE'
    };

    const response = await faceAPI.post('/match', requestData, {
      params: { access_token: token }
    });

    if (response.data.error_code) {
      throw new Error(response.data.error_msg || '人脸验证失败');
    }

    return {
      success: true,
      data: response.data.result
    };
  } catch (error) {
    console.error('人脸验证失败:', error);
    return {
      success: false,
      error: error.message
    };
  }
};

/**
 * 获取用户人脸列表
 * @param {string} userId 用户ID
 * @returns {Promise<Object>} 用户人脸列表
 */
export const getUserFaceList = async (userId) => {
  try {
    const token = await getAccessToken();
    
    const response = await faceAPI.post('/faceset/user/get', {
      user_id: userId,
      group_id: API_CONFIG.GROUP_ID
    }, {
      params: { access_token: token }
    });

    if (response.data.error_code) {
      throw new Error(response.data.error_msg || '获取用户人脸列表失败');
    }

    return {
      success: true,
      data: response.data.result
    };
  } catch (error) {
    console.error('获取用户人脸列表失败:', error);
    return {
      success: false,
      error: error.message
    };
  }
};

/**
 * 删除用户人脸
 * @param {string} userId 用户ID
 * @param {string} faceToken 人脸标识
 * @returns {Promise<Object>} 删除结果
 */
export const deleteUserFace = async (userId, faceToken) => {
  try {
    const token = await getAccessToken();
    
    const response = await faceAPI.post('/faceset/user/delete', {
      user_id: userId,
      group_id: API_CONFIG.GROUP_ID,
      face_token: faceToken
    }, {
      params: { access_token: token }
    });

    if (response.data.error_code) {
      throw new Error(response.data.error_msg || '删除用户人脸失败');
    }

    return {
      success: true,
      data: response.data.result
    };
  } catch (error) {
    console.error('删除用户人脸失败:', error);
    return {
      success: false,
      error: error.message
    };
  }
};

/**
 * 创建用户组
 * @param {string} groupId 用户组ID
 * @returns {Promise<Object>} 创建结果
 */
export const createGroup = async (groupId = API_CONFIG.GROUP_ID) => {
  try {
    const token = await getAccessToken();
    
    const response = await faceAPI.post('/faceset/group/add', {
      group_id: groupId
    }, {
      params: { access_token: token }
    });

    if (response.data.error_code) {
      throw new Error(response.data.error_msg || '创建用户组失败');
    }

    return {
      success: true,
      data: response.data.result
    };
  } catch (error) {
    console.error('创建用户组失败:', error);
    return {
      success: false,
      error: error.message
    };
  }
};

// 默认导出API配置
export default {
  API_CONFIG,
  getAccessToken,
  convertImageToBase64,
  detectFace,
  registerFace,
  searchFace,
  verifyFace,
  getUserFaceList,
  deleteUserFace,
  createGroup
};

